let myfn = {}

/**
 * 登录
 * vk.myfn.login()
 * @returns {Promise}
 * */
myfn.login = () => {
  return new Promise((resolve, reject) => {
    uni.login({
      provider: 'univerify',
      univerifyStyle: {
        fullScreen: true,
        otherLoginButton: {
          visible: true, // 是否显示其他登录按钮，默认值：true
          normalColor: '', // 其他登录按钮正常状态背景颜色 默认值：透明
          highlightColor: '', // 其他登录按钮按下状态背景颜色 默认值：透明
          textColor: '#656565', // 其他登录按钮文字颜色 默认值：#656565
          title: '其他登录方式', // 其他登录方式按钮文字 默认值：“其他登录方式”
          borderColor: '', //边框颜色 默认值：透明（仅iOS支持）
          borderRadius: '0px' // 其他登录按钮圆角 默认值："24px" （按钮高度的一半）
        },
        privacyTerms: {
          defaultCheckBoxState: true, // 条款勾选框初始状态 默认值： true
          isCenterHint: false, //未勾选服务条款时点击登录按钮的提示是否居中显示 默认值: false (3.7.13+ 版本支持)
          uncheckedImage: '', // 可选 条款勾选框未选中状态图片（仅支持本地图片 建议尺寸 24x24px）(3.2.0+ 版本支持)
          checkedImage: '', // 可选 条款勾选框选中状态图片（仅支持本地图片 建议尺寸24x24px）(3.2.0+ 版本支持)
          checkBoxSize: 12, // 可选 条款勾选框大小
          textColor: '#BBBBBB', // 文字颜色 默认值：#BBBBBB
          termsColor: '#5496E3', //  协议文字颜色 默认值： #5496E3
          prefix: '我已阅读并同意', // 条款前的文案 默认值：“我已阅读并同意”
          suffix: '并使用本机号码登录', // 条款后的文案 默认值：“并使用本机号码登录”
          privacyItems: [
            {
              url: 'https://sessss.com', // 点击跳转的协议详情页面
              title: '《钓鱼达人服务协议》' // 协议名称
            }
          ]
        },
        buttons: {
          iconWidth: '45px', // 图标宽度（高度等比例缩放） 默认值：45px
          list: [
            {
              provider: 'apple',
              iconPath: '/static/icoc_login_Apple.png' // 图标路径仅支持本地图片
            },
            {
              provider: 'weixin',
              iconPath: '/static/icoc_login_Wechat.png' // 图标路径仅支持本地图片
            }
          ]
        }
      },
      success: function (res) {
        resolve(res)
      },
      fail: function (err) {
        reject(err)
        console.log('🚀 ~ returnnewPromise ~ err:', err)
        // // 关闭
        // if (err.code == 30003) {
        //   vk.navigateTo('/pages/index/index')
        //   return
        // }
        // // 30002 其他
        // if (err.code == 30003) {
        //   vk.navigateTo('/pages/login/index')
        //   return
        // }
      }
    })
  })
}
/**
 * 处理图片链接
 * vk.myfn.handleImageUrl()
 * @param {String} url 图片链接
 * @returns {String} 处理后的图片链接
 */
myfn.handleImageUrl = url => {
  if (!url) return ''
  if (url.startsWith('http://') || url.startsWith('https://')) {
    return url
  }
  return `${vk.vuex.get('$app.initData.site.cdnUrl')}${url.startsWith('/') ? '' : '/'}${url}` // 这里替换成你的域名
}

/**
 * 验证手机号
 * vk.myfn.validatePhone()
 * @param {String} phone 手机号
 * @returns {Boolean}
 */
myfn.validatePhone = phone => {
  const reg = /^1[3-9]\d{9}$/
  return reg.test(phone)
}

//  * vk.myfn.previewImage({
//  *   urls: ['https://example.com/image1.jpg', 'https://example.com/image2.jpg'],
//  *   current: 1 // 显示第二张图片
//  * })
/**
 * 图片预览
 * vk.myfn.previewImage()
 * @param {Object} options 配置选项
 * @param {Array} options.urls 需要预览的图片链接列表
 * @param {Number|String} options.current 当前显示图片的链接/索引
 * @returns {Promise}
 */
myfn.previewImage = (options = {}) => {
  return new Promise((resolve, reject) => {
    const { urls = [], current = 0 } = options

    // 处理图片链接
    const imageUrls = urls.map(url => myfn.handleImageUrl(url))

    // 处理当前图片
    let currentImg = current
    if (typeof current === 'string') {
      currentImg = myfn.handleImageUrl(current)
    }

    uni.previewImage({
      urls: imageUrls,
      current: currentImg,
      success: res => {
        resolve(res)
      },
      fail: err => {
        console.error('预览图片失败:', err)
        reject(err)
      }
    })
  })
}

/**
 * 格式化时间
 * vk.myfn.formatTime()
 * @param {String} date 时间戳
 * @returns {String}
 */
myfn.formatTime = date => {
  const formatter = new Date(date.replace(/-/g, '/'))

  const now = new Date()
  const diff = Math.abs(now - formatter) / 1000 // 时间差，单位为秒
  const intervals = {
    年: 31536000,
    个月: 2592000,
    天: 86400,
    小时: 3600,
    分钟: 60,
    秒: 1
  }
  for (let unit in intervals) {
    const value = Math.floor(diff / intervals[unit])
    if (value > 0) {
      return value === 1 ? `1 ${unit}前` : `${value} ${unit}前`
    }
  }
  return '刚刚'
}

/**
 * 对象转字符串
 * vk.myfn.objToString()
 * @param {Object} obj 对象
 * @returns {String}
 */
myfn.objToString = obj => {
  let str = '?'
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      str += `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}&`
    }
  }
  return str.slice(0, -1)
}
/**
 * 打开地图
 * vk.myfn.openMap()
 * @param {Number} latitude 纬度
 * @param {Number} longitude 经度
 * @param {String} name 名称
 * @param {Number} scale 缩放比例
 * @returns {void}
 * */
myfn.openMap = (latitude, longitude, name, scale) => {
  uni.openLocation({
    latitude: Number(latitude),
    longitude: Number(longitude),
    name: name || '目的地',
    scale: scale || 18
  })
}

/**
 * 复制内容到剪贴板
 * vk.myfn.copyToClipboard()
 * @param {String} text 要复制的内容
 * @returns {Promise}
 */
myfn.copyToClipboard = text => {
  return new Promise((resolve, reject) => {
    uni.setClipboardData({
      data: String(text),
      showToast: false,
      success: function () {
        resolve()
      },
      fail: function (err) {
        reject(err)
      }
    })
  })
}

/**
 * 选择位置
 * vk.myfn.chooseLocation()
 * @returns {Promise}
 */
myfn.chooseLocation = () => {
  return new Promise((resolve, reject) => {
    uni.chooseLocation({
      success: function (res) {
        resolve(res)
      },
      fail: function (err) {
        reject(err)
      }
    })
  })
}

/**
 * 图片上传
 * vk.myfn.uploadImage()
 * @param {Object} options 配置选项
 * @param {Number} options.count 选择图片数量，默认1
 * @param {String} options.topic 主题分类，默认'images'
 * @param {Function} options.onSuccess 上传成功回调
 * @param {Function} options.onFail 上传失败回调
 * @returns {Promise}
 */
myfn.uploadImage = (options = {}) => {
  return new Promise((resolve, reject) => {
    const { count = 1, topic = 'images', onSuccess, onFail } = options

    // 生成随机字符串函数
    function random_string(len) {
      len = len || 32
      var chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678'
      var maxPos = chars.length
      var pwd = ''
      for (let i = 0; i < len; i++) {
        pwd += chars.charAt(Math.floor(Math.random() * maxPos))
      }
      return pwd
    }

    uni.chooseImage({
      count: count,
      sizeType: ['original', 'compressed'],
      sourceType: ['album', 'camera'],
      success: function (res) {
        console.log('选择图片成功:', res)
        let tempFile = res.tempFiles[0]
        let suffix = ''

        // 判断是APP还是H5环境,分别处理文件名
        if (uni.getSystemInfoSync().platform === 'android' || uni.getSystemInfoSync().platform === 'ios') {
          // APP环境下从文件路径中提取后缀
          let pathArr = tempFile.path.split('.')
          suffix = pathArr.length > 1 ? `.${pathArr.pop().toLowerCase()}` : '.jpg'
        } else {
          // H5环境下从文件名中提取后缀
          suffix = tempFile.name ? `.${tempFile.name.split('.').pop().toLowerCase()}` : '.jpg'
        }

        // 获取当前日期
        let date = new Date()
        let year = date.getFullYear()
        let month = String(date.getMonth() + 1).padStart(2, '0')
        let day = String(date.getDate()).padStart(2, '0')

        // 生成文件名
        let randomStr = random_string(8)
        let timestamp = new Date().getTime()
        let fileName = `storage/${topic}/${year}${month}${day}/${timestamp}_${randomStr}${suffix}`

        // 开始上传
        myfn
          .fileUpload('image', res.tempFilePaths[0], fileName)
          .then(url => {
            if (onSuccess) onSuccess(url)
            resolve(url)
          })
          .catch(err => {
            if (onFail) onFail(err)
            reject(err)
          })
      },
      fail: function (err) {
        console.log('选择图片失败:', err)
        if (onFail) onFail(err)
        reject(err)
      }
    })
  })
}

/**
 * 文件上传到OSS
 * vk.myfn.fileUpload()
 * @param {String} type 文件类型
 * @param {String} path 文件路径
 * @param {String} storeAs 存储路径
 * @returns {Promise}
 */
myfn.fileUpload = (type, path, storeAs) => {
  return new Promise((resolve, reject) => {
    uni.showLoading({
      title: '文件上传中'
    })
    api
      .init()
      .then(res => {
        var data = res.data.site.upload
        var osshost = 'https://basan.oss-cn-chengdu.aliyuncs.com/'

        uni.uploadFile({
          url: data.url,
          filePath: path,
          fileType: type,
          name: 'file',
          formData: {
            key: storeAs,
            policy: data.params.policy,
            OSSAccessKeyId: data.params.OSSAccessKeyId,
            success_action_status: '200',
            Signature: data.params.Signature
          },
          success: res => {
            console.log('上传成功:', res)
            if (res.statusCode == 200) {
              const url = osshost + storeAs
              console.log('文件URL:', url)
              uni.hideLoading()
              resolve(url)
            } else {
              uni.hideLoading()
              reject(new Error('上传失败'))
            }
          },
          fail: err => {
            console.log('上传失败:', err)
            uni.hideLoading()
            uni.showModal({
              content: err.errMsg,
              showCancel: false
            })
            reject(err)
          }
        })
      })
      .catch(err => {
        uni.hideLoading()
        reject(err)
      })
  })
}

/**
 * 视频上传
 * vk.myfn.uploadVideo()
 * @param {Object} options 配置选项
 * @param {Number} options.count 选择视频数量，默认1
 * @param {String} options.topic 主题分类，默认'videos'
 * @param {Number} options.maxDuration 最大录制时长（秒），默认60
 * @param {Function} options.onSuccess 上传成功回调
 * @param {Function} options.onFail 上传失败回调
 * @returns {Promise}
 */
myfn.uploadVideo = (options = {}) => {
  return new Promise((resolve, reject) => {
    const { count = 1, topic = 'videos', maxDuration = 60, onSuccess, onFail } = options

    // 生成随机字符串函数
    function random_string(len) {
      len = len || 32
      var chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678'
      var maxPos = chars.length
      var pwd = ''
      for (let i = 0; i < len; i++) {
        pwd += chars.charAt(Math.floor(Math.random() * maxPos))
      }
      return pwd
    }

    uni.chooseVideo({
      count: count,
      sourceType: ['album', 'camera'],
      maxDuration: maxDuration,
      camera: 'back',
      success: function (res) {
        console.log('选择视频成功:', res)

        // 检查文件大小（可选，根据需要调整限制）
        const maxSize = 50 * 1024 * 1024 // 50MB
        if (res.size > maxSize) {
          const error = new Error('视频文件过大，请选择小于50MB的视频')
          if (onFail) onFail(error)
          reject(error)
          return
        }

        // 获取当前日期
        let date = new Date()
        let year = date.getFullYear()
        let month = String(date.getMonth() + 1).padStart(2, '0')
        let day = String(date.getDate()).padStart(2, '0')

        // 生成文件名 - 修复：从 res.name 获取后缀而不是 tempFilePath
        let suffix = ''
        if (res.name) {
          suffix = res.name.split('.').pop().toLowerCase()
          suffix = suffix ? `.${suffix}` : '.mp4'
        } else {
          suffix = '.mp4' // 默认为mp4格式
        }

        let randomStr = random_string(8)
        let timestamp = new Date().getTime()
        let fileName = `storage/${topic}/${year}${month}${day}/${timestamp}_${randomStr}${suffix}`

        // 开始上传
        myfn
          .fileUpload('video', res.tempFilePath, fileName)
          .then(url => {
            const result = {
              url: url,
              duration: res.duration,
              size: res.size,
              width: res.width,
              height: res.height
            }
            if (onSuccess) onSuccess(result)
            resolve(result)
          })
          .catch(err => {
            if (onFail) onFail(err)
            reject(err)
          })
      },
      fail: function (err) {
        console.log('选择视频失败:', err)
        if (onFail) onFail(err)
        reject(err)
      }
    })
  })
}

/**
 * 根据时间戳计算时间差
 * vk.myfn.getTimeAgo()
 * @param {Number|String} timestamp 时间戳
 * @returns {String} 格式化后的时间差
 */
myfn.getTimeAgo = timestamp => {
  // 将时间戳转换为毫秒
  const timeMs = typeof timestamp === 'string' ? parseInt(timestamp) * 1000 : timestamp * 1000
  const date = new Date(timeMs)
  const now = new Date()

  // 计算时间差（毫秒）
  const diff = now - date

  // 转换为秒
  const seconds = Math.floor(diff / 1000)

  // 定义时间间隔
  const intervals = {
    年: 31536000,
    个月: 2592000,
    周: 604800,
    天: 86400,
    小时: 3600,
    分钟: 60
  }

  // 判断时间差并返回对应文本
  if (seconds < 60) {
    return '刚刚'
  }

  for (let [unit, secondsInUnit] of Object.entries(intervals)) {
    const interval = Math.floor(seconds / secondsInUnit)

    if (interval >= 1) {
      return `${interval}${unit}前`
    }
  }

  // 如果时间太久远，返回具体日期
  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
}

/**
 * 选择位置
 * vk.myfn.chooseLocation()
 * @returns {Promise<Object>} 返回位置信息对象,包含name(位置名称),address(详细地址),latitude(纬度),longitude(经度)
 */
myfn.chooseLocation = () => {
  return new Promise((resolve, reject) => {
    uni.chooseLocation({
      success: function (res) {
        console.log('位置名称：' + res.name)
        console.log('详细地址：' + res.address)
        console.log('纬度：' + res.latitude)
        console.log('经度：' + res.longitude)
        resolve({
          name: res.name,
          address: res.address,
          latitude: res.latitude,
          longitude: res.longitude
        })
      },
      fail: function (err) {
        console.error('选择位置失败:', err)
        reject(err)
      }
    })
  })
}

export default myfn
